portals/publisher/src/main/webapp/source/src/app/components/Apis/Details/Environments/DeploymentOnbording.jsx (1)

232-237: Default vhost selection can pick WS‑disabled vhosts for WebSocket APIs

For WS APIs, defaultVhosts always uses e.vhosts[0] via getHostValue(e.vhosts[0], api.isWebSocket()). If the first vhost has WS endpoints disabled while a later vhost has them enabled, hasValidHosts(row) will still be true (because some vhost is valid), but the default selection for that env will point at the wrong vhost and be used in createDeployRevision.

To avoid deploying a WS API to a vhost where WS is disabled, base the default host on the first vhost that actually has valid WS endpoints when api.isWebSocket() is true.

-            const defaultVhosts = selectedInternalGateways.map((e) => {
-                if (e.vhosts && e.vhosts.length > 0) {
-                    return {
-                        env: e.name,
-                        vhost: getHostValue(e.vhosts[0], api.isWebSocket()),
-                    };
-                } else {
-                    return undefined;
-                }
-            });
+            const defaultVhosts = selectedInternalGateways.map((e) => {
+                if (!e.vhosts || e.vhosts.length === 0) {
+                    return undefined;
+                }
+                const candidates = api.isWebSocket()
+                    ? e.vhosts.filter((v) => hasValidWebSocketPorts(v))
+                    : e.vhosts;
+                const first = candidates[0];
+                return first
+                    ? { env: e.name, vhost: getHostValue(first, api.isWebSocket()) }
+                    : undefined;
+            });
@@
-                const defaultVhosts = selectedExternalGateways.map((e) => {
-                    if (e.vhosts && e.vhosts.length > 0) {
-                        return {
-                            env: e.name,
-                            vhost: getHostValue(e.vhosts[0], api.isWebSocket()),
-                        };
-                    } else {
-                        return undefined;
-                    }
-                });
+                const defaultVhosts = selectedExternalGateways.map((e) => {
+                    if (!e.vhosts || e.vhosts.length === 0) {
+                        return undefined;
+                    }
+                    const candidates = api.isWebSocket()
+                        ? e.vhosts.filter((v) => hasValidWebSocketPorts(v))
+                        : e.vhosts;
+                    const first = candidates[0];
+                    return first
+                        ? { env: e.name, vhost: getHostValue(first, api.isWebSocket()) }
+                        : undefined;
+                });

Also applies to: 253-258

portals/publisher/src/main/webapp/source/src/app/components/Apis/Details/Environments/Environments.jsx (1)

608-619: Default vhost selection for WS APIs can still pick a vhost with WS disabled

As in DeploymentOnbording.jsx, defaultVhosts here always uses e.vhosts[0] and wraps it with getHostValue(e.vhosts[0], api.isWebSocket()). For WS APIs, if the first vhost has WS endpoints disabled but a later vhost has them enabled, hasValidHosts(e) will be true, yet the default selection will target the WS‑disabled vhost and be used in deployments.

This undermines the intent of the new validity checks.

Refine the default selection to prefer a vhost with valid WS endpoints for WS APIs:

-                const defaultVhosts = selectedInternalGateways.map((e) => {
-                    if (e.vhosts && e.vhosts.length > 0) {
-                        return {
-                            env: e.name,
-                            vhost: getHostValue(e.vhosts[0], api.isWebSocket())
-                        };
-                    } else {
-                        return undefined;
-                    }
-                });
+                const defaultVhosts = selectedInternalGateways.map((e) => {
+                    if (!e.vhosts || e.vhosts.length === 0) {
+                        return undefined;
+                    }
+                    const candidates = api.isWebSocket()
+                        ? e.vhosts.filter((v) => hasValidWebSocketPorts(v))
+                        : e.vhosts;
+                    const first = candidates[0];
+                    return first
+                        ? { env: e.name, vhost: getHostValue(first, api.isWebSocket()) }
+                        : undefined;
+                });
@@
-                    const defaultVhosts = selectedExternalGateways.map((e) => {
-                        if (e.vhosts && e.vhosts.length > 0) {
-                            return {
-                                env: e.name,
-                                vhost: getHostValue(e.vhosts[0], api.isWebSocket())
-                            };
-                        } else {
-                            return undefined;
-                        }
-                    });
+                    const defaultVhosts = selectedExternalGateways.map((e) => {
+                        if (!e.vhosts || e.vhosts.length === 0) {
+                            return undefined;
+                        }
+                        const candidates = api.isWebSocket()
+                            ? e.vhosts.filter((v) => hasValidWebSocketPorts(v))
+                            : e.vhosts;
+                        const first = candidates[0];
+                        return first
+                            ? { env: e.name, vhost: getHostValue(first, api.isWebSocket()) }
+                            : undefined;
+                    });

This keeps default behavior unchanged for HTTP APIs, while ensuring WS APIs default to a vhost where WS is actually enabled.

Also applies to: 631-642

portals/publisher/src/main/webapp/source/src/app/components/Apis/Details/Environments/DeploymentOnbording.jsx (1)

215-241: For WS APIs, default vhost should prefer the first WS‑valid vhost, not always index 0

You now store host strings via getHostValue(e.vhosts[0], api.isWebSocket()). For WebSocket APIs this still blindly uses the first vhost even if it has WS endpoints disabled while a later vhost is WS‑enabled. In that case:

• hasValidHosts(row, api.isWebSocket()) will enable the environment (because at least one vhost is valid),
• but selectedVhostDeploy will still hold the disabled vhost’s host value until the user manually changes it.

Safer to choose the first WS‑valid vhost when api.isWebSocket():

-            const defaultVhosts = selectedInternalGateways.map((e) => {
-                if (e.vhosts && e.vhosts.length > 0) {
-                    return {
-                        env: e.name,
-                        vhost: getHostValue(e.vhosts[0], api.isWebSocket()),
-                    };
-                } else {
-                    return undefined;
-                }
-            });
+            const defaultVhosts = selectedInternalGateways.map((e) => {
+                if (!e.vhosts || e.vhosts.length === 0) {
+                    return undefined;
+                }
+                const baseVhost = api.isWebSocket()
+                    ? (e.vhosts.find((v) => hasValidWebSocketPorts(v)) || e.vhosts[0])
+                    : e.vhosts[0];
+                return {
+                    env: e.name,
+                    vhost: getHostValue(baseVhost, api.isWebSocket()),
+                };
+            });

Apply the same pattern in the external‑gateway branch below for consistency.

portals/publisher/src/main/webapp/source/src/app/components/Apis/Details/Environments/Environments.jsx (1)

590-600: Mirror “choose first WS‑valid vhost” here for consistency with onboarding

As in DeploymentOnbording.jsx, default vhosts for each environment are still based on e.vhosts[0], now wrapped in getHostValue. For WS APIs this can select a WS‑disabled vhost even when a later vhost is WS‑enabled, leaving selectedVhosts/selectedVhostDeploy pointing at a disabled host until the user changes it.

To keep defaults aligned with your new validity helpers and avoid that subtle mismatch, consider:

-                const defaultVhosts = selectedInternalGateways.map((e) => {
-                    if (e.vhosts && e.vhosts.length > 0) {
-                        return {
-                            env: e.name,
-                            vhost: getHostValue(e.vhosts[0], api.isWebSocket())
-                        };
-                    } else {
-                        return undefined;
-                    }
-                });
+                const defaultVhosts = selectedInternalGateways.map((e) => {
+                    if (!e.vhosts || e.vhosts.length === 0) {
+                        return undefined;
+                    }
+                    const baseVhost = api.isWebSocket()
+                        ? (e.vhosts.find((v) => hasValidWebSocketPorts(v)) || e.vhosts[0])
+                        : e.vhosts[0];
+                    return {
+                        env: e.name,
+                        vhost: getHostValue(baseVhost, api.isWebSocket()),
+                    };
+                });

and similarly in the external‑gateway branch below.

Also applies to: 613-625